var BaseUrl = "/iptwap/";
var ajaxUrl = "/iptwap/ajax.do";
/**
 * 调试
 */
var AjaxDebug = false;
/**
 * 是否弹出ajax结果提示
 */
var isAjaxAlert = false;
/**
 * 保存ajax前的:input状态
 */
var _input_status = new Array();
/**
 * 保存最后一次ajax后的返回结果，类型为一个map  returnData['xx']
 */
var returnData = null;
/**
 * 上传状态
 */
var uploadStatus = false;
/**
 * 暂存页面变量， 使用pageMap["xx"]
 */
var pageMap = new Object();
/**
 * 获取违章照片的url
 */
var wzPhoneUrl = BaseUrl + "search/get_vio_pic.do?";
/**
 * 获取高清违章照片的url
 */
var wzPhoneHDUrl = BaseUrl + "search/get_vio_pic_hd.do?";
/**
 * 初始化一些必须在窗口加载完成之后才能获取的参数
 */
function getTopHight(){
    try{
        return $( window ).scrollTop();
    }catch(e){
        return 0;
    }
}
/*
 * 在jquery mobile js库之后运行
 */
$(document).ready(function(){
    $(":input").focus(function(){
        var top = $(this).context.offsetTop + (window.innerHeight / 2) + $(this).context.offsetHeight;
        debugAlert("top = " +top);
        $.mobile.silentScroll(top);
    });
});
/**
 * 获取html5中的sessionStorage值，把值封闭成ajax需要的格式，如：&session=123
 */
function getSession(){
    var checkId = "&psw=112359";
    if (sessionStorage["phoneNum"]){
        return checkId + "&_phone_num=" + sessionStorage["phoneNum"];
    }else{
        return checkId;
    }
}

/**
 * 一个简单的弹出示提示框
 * @param msg 要提示的信息
 * @param time 持续时间
 * @param top 距顶部的距离,默认150px
 */
function showDialog(msg, time, top){
    if (!time) time = 400;
    showErrorDialog(msg, time, top);
}


/**
 * 一个简单的弹出示错误提示框
 * @param msg 要提示的信息
 * @param top 距顶部的距离,默认150px
 * @param time 持续时间
 */
function showErrorDialog(msg, time, top){
    if (!top){
        top = getTopHight() + 150;
    }
    if (!time){
        time = 5000;
    }
    $( "<div class='ui-loader ui-overlay-shadow ui-body-e ui-corner-all'><h1>"+ msg +"</h1></div>" )
    .css({
        "display": "block",
        "opacity": 0.96,
        "top": top
    })
    .appendTo( $("body") )
    .delay( 800 )
    .fadeOut( time, function() {
        $( this ).remove();
    });
}

/**
 * 使用快捷键  F9  开关debug
 * 使用快捷键  F8  开关ajax提示
 */
$(document).keydown(function(){
    switch(event.keyCode){
        case 120:       //F9
            if (AjaxDebug){
                alert("alert debug 已关闭！");
                $("#_debug_button").attr("value", "debug 未开启");
                AjaxDebug = false;
            }else{
                alert("alert debug 已开启！");
                $("#_debug_button").attr("value", "debug 已开启");
                AjaxDebug = true;
            }
            break;
        case 119:       //F8
            if (isAjaxAlert){
                alert("ajax提示已关闭！");
                isAjaxAlert = false;
            }else{
                alert("ajax提示已开启！");
                isAjaxAlert = true;
            }
            break;
        default:
            break;
    }
});

/**
 * 删除所有表单的默认提交事件，
 * 在form中点击回车键是默认的提交事件
 */
$(document).ready(function(){
    $("form").submit(function(){
        return false;
    });
});

/**
 * 调试信息对话框
 * @param obj 对话框信息
 */
function debugAlert(obj){
    if (AjaxDebug){
        if(!confirm(obj + "\n\n\n是否继续显示调试信息?")){
            AjaxDebug = false;
            $("#_debug_button").attr("value", "debug 未开启");
        }
    }
}

/**
 * 在一个标签中增加一个debug开关，该开关可以开启或关闭debug状态
 * @param id 标签id
 */
function debugAlertButton(id){
    var _value;
    if (AjaxDebug){
        _value = "debug 已开启";
    }else{
        _value = "debug 未开启";
    }
    $("#" + id).append("<input id = '_debug_button' type='button' class='debug_button' value='" + _value + "'/>");
    $("#_debug_button").click(function(){
        if (AjaxDebug){
            AjaxDebug = false;
            $(this).attr("value", "debug 未开启");
        }else{
            AjaxDebug = true;
            $(this).attr("value", "debug 已开启");
        }
    });
}

/**
 * 执行ajax时把所有input的attribute属性置为value
 * 适用 disabled:disabled readOnly:readOnly display:none 等
 * @param attribute input属性名
 * @param value 属性值
 */
function _inputStatus(attribute, value){
    _input_status = new Array();
    if (!value){
        value = attribute;
        debugAlert("value值为空，使用attribute名做为value值：" + value);
    }
    $(":input[" + attribute + "][" + attribute + "!='']").each(function(){
        _input_status[_input_status.length] = $(this);
    });
    $(":input").attr(attribute, value);
    debugAlert("有 " + _input_status.length + " 个input的" + attribute + "属性为不为空");
}

/**
 * 把input的attribute恢复到ajax前
 * 适用 disabled:disabled readOnly:readOnly display:none 等
 * attribute, value的值必须与运行_inputStatus()时的相同
 * @param attribute input属性名
 * @param value 属性值
 */
function _rdInputStatus(attribute, value){
    if (!value){
        value = attribute;
        debugAlert("value值为空，使用attribute名做为value值：" + value);
    }
    $(":input").attr(attribute, "");
    for(var index in _input_status){
        _input_status[index].attr(attribute, value);
    }
    debugAlert("有 " + _input_status.length + " 个input的" + attribute + "属性为" + value);
    _input_status = null;
}

/**
 * 当前 时间
 */
function getNowTime(){
    var time = new Date();
    return time.getHours() + ":" + time.getMinutes() + ":" + time.getSeconds();
}

/**
 * 当前 日期 + 时间
 */
function getNowDateTime(){
    var time = new Date();
    return time.getYear() + "-" + (time.getMonth() + 1) + "-" + time.getDate() + " "
    + time.getHours() + ":" + time.getMinutes() + ":" + time.getSeconds();
}

/**
 * 当前 日期
 */
function getNowDate(){
    var time = new Date();
    return time.getYear() + "-" + (time.getMonth() + 1) + "-" + time.getDate();
}

/**
 * Ajax的Options对象，可对Ajax进行详细设置
 * 该类仅为方便代码开发
 * @param formId 要提交的表单
 * @param async 所有请求均为异步请求。如果需要发送同步请求，请将此项设置为false
 * @param data 数据， 可使用structFormData() 或 $("form").serialize() 方法生成
 * @param sus 成功时的回调函数
 */
AjaxOptions = function(formId, data, sus, async){
    /**
     * 在执行ajax请求过程中是否出现提示<br />类型：boolean
     */
    this.isAlert = true;
    /**
     * 所有请求均为异步请求。如果需要发送同步请求，请将此项设置为false
     * 类型： Boolean
     */
    this.async = true;
    if (async != undefined){
        this.async = async;
    }

    /**
     * 要提交的表单
     */
    this.form = $("#" + formId);
    if (!this.form.attr("method")){//判断表单是否为空
        this.form = $("form[name='"+formId+"']");
        if (!this.form.attr("method")){//判断表单是否为空
            this.form = false;
        }
    }

    /**
     * (默认：true， dataType为script和jsonp时默认为false) 设置为false将不缓存此页面
     * 类型 Boolean
     */
    this.cache = false;

    /**
     * 类型： String
     */
    this.url = ajaxUrl;
    //    this.url = $.trim(url);
    //    if (this.form){//判断表单是否为空
    //        this.url = this.form.attr("action");
    //    }
    //    if (this.url){
    //    }else{
    //        this.url = $("form:eq(0)").attr("action");
    //    }

    /**
     * 类型： Object
     */
    this.data = undefined;
    if (data){
        this.data = data;
    }else{
        if (this.form){//判断表单是否为空
            this.data = this.form.serialize();
        }else{
            this.data = $("form").serialize();                  //页面中所有表单元素
        }
    }
    if (!this.data){
        this.data = "";
    }

    /**
     * 默认的成功回调函数
     * @param data 服务器返回的数据
     */
    this.success = function(data){
        //        returnData = explStrData(data);
        returnData =  eval('(' + data + ')');       //把字符串转为json
        if(returnData.head.response_code != "000000"){
            //异常处理
            debugAlert("异常代码=" + returnData.head.response_code + "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 描述=" + returnData.head.response_desc);
            showErrorDialog(returnData.head.response_desc);
            if ($.isFunction(this.fal)){
                debugAlert("执行异常，开始运行！");
                this.fal(returnData.head.response_code, returnData.head.response_desc);
                return;
            }
        }
        padBackData(returnData);        //把返回数据回填到页面
        this.responseData = returnData;     //需要把返回数据的处理 和页面的控制分离。
    };

    /**
     * 请求完成后回调函数 (请求成功或失败之后均调用)。
     * 参数： XMLHttpRequest 对象和一个描述成功请求类型的字符串。
     * 类型： function(XMLHttpRequest, textStatus)
     */
    this.complete = function(request, status){
        if (this.async){
        //            _rdInputStatus("disabled", "disabled");
        }
        if (status == "success"){
            if(returnData.head.response_code == "000000"){
                if (this.isAlert){
                    showDialog("操作成功！");
                }
                if ($.isFunction(this.sus)){
                    debugAlert("开始执行自定义的成功回调函数！");
                    this.sus(returnData);
                }
            }
            if ($.isFunction(this.after)){
                debugAlert("开始执行finally函数");
                this.after(returnData.head.response_code, returnData.head.response_desc);
            }
        }
    //        getReturnDateObj().append(" &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;结束： " + getNowTime());
    };

    /**
     * 发送请求前可修改 XMLHttpRequest 对象的函数，如添加自定义 HTTP 头。XMLHttpRequest 对象是唯一的参数。
     * 这是一个 Ajax 事件。如果返回false可以取消本次ajax请求。
     * 类型： function(XMLHttpRequest)
     */
    this.beforeSend = function (XMLHttpRequest){
        var locationUrl = window.location.toString().replace(/\?/g, "!").replace(/\&/g, "`");   //当前页面的URL 使用 ! 替换 ? 号
        locationUrl = locationUrl.substr(locationUrl.indexOf(BaseUrl) + BaseUrl.length);
        if (locationUrl.indexOf(0) != "/"){
            locationUrl = "/" + locationUrl;
        }
        this.data = this.data + "&_begin_url=" + locationUrl + "&_target_url=" + this.url + "&_type=ajax" + getSession();                //目标页面的URL
        var nowTime = getNowTime();
        if (this.async){
        //            _inputStatus("disabled", "disabled");
        }
        debugAlert("url:\t" + this.url + "\ndata:\t" + this.data.replace(/&/g, "\n\t")
            + "\ntype:\t" + this.type + "\ntime:\t" + nowTime);
        //        if (!this.url || this.url.charAt(0) == "?"){
        //            this.url = ajaxUrl + this.url;
        //        }
        this.url = ajaxUrl;
        //        if (this.url && this.url.charAt(0) != "?"){
        if (this.isAlert){
            showDialog("正在处理，请稍后......");
        }
        //            getReturnDateObj().html("开始：" + nowTime);
        return true;
    //        }else{
    //            showErrorDialog("请求地址为空！");
    //            getReturnDateObj().html("开始：" + nowTime);
    //            return false;
    //        }
    };

    /**
     * (默认: "application/x-www-form-urlencoded") 发送信息至服务器时内容编码类型。默认值适合大多数情况。
     * 如果你明确地传递了一个content-type给 $.ajax() 那么他必定会发送给服务器（即使没有数据要发送）
     * 类型： String
     */
    this.contentType = "application/x-www-form-urlencoded; charset=utf-8";

    /**
     * 这个对象用于设置Ajax相关回调函数的上下文。
     * 也就是说，让回调函数内this指向这个对象（如果不设定这个参数，那么this就指向调用本次AJAX请求时传递的options参数）。
     * 比如指定一个DOM元素作为context参数，这样就设置了success回调函数的上下文为这个DOM元素。
     * 类型：Object； (document.body)
     */
    this.context = undefined;

    /**
     * 给Ajax返回的原始数据的进行预处理的函数。
     * 提供data和type两个参数：data是Ajax返回的原始数据，type是调用jQuery.ajax时提供的dataType参数。
     * 函数返回的值将由jQuery进一步处理。
     * 类型： function(data, type)
     */
    this.dataFilter = function (data, type){
        if (type){
            debugAlert("dataFilter-->data type:" + type);
        }
        return data;
    };

    /**
     * 预期服务器返回的数据类型。
     * 如果不指定，jQuery 将自动根据 HTTP 包 MIME 信息来智能判断，比如XML MIME类型就被识别为XML。
     * 在1.4中，JSON就会生成一个JavaScript对象，而script则会执行这个脚本。随后服务器端返回的数据会根据这个值解析后，传递给回调函数。可用值:
     *      "xml": 返回 XML 文档，可用 jQuery 处理。
     *      "html": 返回纯文本 HTML 信息；包含的script标签会在插入dom时执行。
     *      "script": 返回纯文本 JavaScript 代码。不会自动缓存结果。除非设置了"cache"参数。'''注意：'''在远程请求时(不在同一个域下)，所有POST请求都将转为GET请求。(因为将使用DOM的script标签来加载)
     *      "json": 返回 JSON 数据 。
     *      "jsonp": JSONP 格式。使用 JSONP 形式调用函数时，如 "myurl?callback=?" jQuery 将自动替换 ? 为正确的函数名，以执行回调函数。
     *      "text": 返回纯文本字符串
     * 类型：String
     */
    this.dataType = undefined;

    /**
     * (默认: 自动判断 (xml 或 html)) 请求失败时调用此函数。
     * 有以下三个参数：XMLHttpRequest 对象、错误信息、（可选）捕获的异常对象。
     * 如果发生了错误，错误信息（第二个参数）除了得到null之外，还可能是"timeout", "error", "notmodified" 和 "parsererror"。
     * 类型： function(XMLHttpRequest, textStatus, errorThrow)
     */
    this.error = function(request, status, error){
        switch(status){
            case "timeout":
                debugAlert("请求超时!");
                showErrorDialog("请求超时！");
                break;
            case "error":
            case "notmodified":
            case "parsererror":
                var error_msg = null;
                try{
                    if (request.status == 0 || request.status == 1 || request.status == 2 || request.status == 3){
                        //0 (未初始化), 1 (正在装载), 2 (装载完毕), 3 (交互中), 4 (完成)
                        error_msg = "系统正在等待响应，请稍后。";
                    }else{
                        error_msg = _error_info[request.status];
                        if (!error_msg){
                            error_msg = "错误代码未定义！";
                            debugAlert("错误代码未定义！");
                        }
                    }
                }catch(e){
                    debugAlert("function : AjaxOptions.error()\nname : " + e.name + "\nmessage : " + e.message + "\n 错误信息未引入！");
                    error_msg = "错误代码未定义！";
                }
                debugAlert("("+request.status+")"+error_msg);
                showErrorDialog(error_msg);
                break;
            default:
                debugAlert("服务器未响应！");
                showErrorDialog("服务器未响应！");
                break;
        }
        if ($.isFunction(this.fal)){
            debugAlert("开始执行自定义的异常回调函数！");
            this.fal(request.status, error_msg);
        }
        if ($.isFunction(this.after)){
            debugAlert("开始执行finally函数");
            this.after(request.status, error_msg);
        }
    };

    /**
     * (默认: true) 是否触发全局 AJAX 事件。设置为 false 将不会触发全局 AJAX 事件.
     */
    this.global = true;

    /**
     * (默认: false) 仅在服务器数据改变时获取新数据。使用 HTTP 包 Last-Modified 头信息判断。
     */
    this.ifModified = false;

    /**
     * 在一个jsonp请求中重写回调函数的名字。
     * 这个值用来替代在"callback=?"这种GET或POST请求中URL参数里的"callback"部分，
     * 比如{jsonp:'onJsonPLoad'}会导致将"onJsonPLoad=?"传给服务器。
     * 类型： String
     */
    this.jsonp = undefined;

    /**
     * 为jsonp请求指定一个回调函数名。
     * 这个值将用来取代jQuery自动生成的随机函数名。
     * 这主要用来让jQuery生成度独特的函数名，这样管理请求更容易，也能方便地提供回调函数和错误处理。
     * 你也可以在想让浏览器缓存GET请求的时候，指定这个回调函数名。
     * 类型： String
     */
    this.jsonpCallback = undefined;

    /**
     * 用于响应HTTP访问认证请求的密码
     * 类型： String
     */
    this.password = undefined;

    /**
     * (默认: true) 默认情况下，通过data选项传递进来的数据，
     * 如果是一个对象(技术上讲只要不是字符串)，都会处理转化成一个查询字符串，以配合默认内容类型 "application/x-www-form-urlencoded"。
     * 如果要发送 DOM 树信息或其它不希望转换的信息，请设置为 false。
     */
    this.processData = true;

    /**
     * 只有当请求时dataType为"jsonp"或"script"，并且type是"GET"才会用于强制修改charset。通常只在本地和远程的内容编码不同时使用。
     * 类型： String
     */
    this.scriptCharset = undefined;

    /**
     * 用于响应HTTP访问认证请求的用户名
     * 类型： String
     */
    this.username = undefined;

    /**
     * 注：当请求为异步时有效
     * 类型： Number
     */
    this.timeout = 10000;

    /**
     * 类型： String
     */
    this.type = "post";

    /**
     * 自定义的成功回调函数
     * @param data ajax返回的数据
     */
    this.sus = undefined;
    if ($.isFunction(sus)){
        this.sus = sus;
    }

    /**
     * 自定义的异常回调函数
     */
    this.fal = function(code, desc){
    //alert("系统错误: " + code + " -- " + desc);
    };

    /**
     * 自定义的finally函数
     */
    this.after = function(code, desc){

    };
    /**
     * 服务器返回的数据 map类型
     */
    this.responseData = undefined;
    /**
     * 向data中增加参数
     */
    this.put = function(key, value){
        this.data = this.data.putParam(key, value);
    };
    /**
     * 获取data中的值
     */
    this.get = function(key){
        return this.data.getParam(key);
    };
    /**
     * 删除data中的参数
     */
    this.remove = function(key){
        this.data = this.data.remove(key);
    };
};

/**
 * 提供一个表格的数据对象
 */
TableData = function(data){
    /**
     * 表格ID
     */
    var tableId = undefined;
    /**
     * 主键名
     */
    var primary = undefined;
    /**
     * 主键名 数组
     */
    var primaryArr = undefined;
    /**
     * 表格数据 二维数组
     */
    var datagrid = undefined;

    return {
        tableId : tableId,
        primary : primary,
        primaryArr : primaryArr,
        datagrid : datagrid
    };
};
/**
 * 把一个简单的数据对象回填到页面
 * @param data： ajax返回数据
 * @param form： form名 可选
 * @return Boolean
 */
function padBackData(data, form){
    //表格数据回填，目前服务器端只能处理一个表格，但客户端的JS(下面一段代码)可处理多个
    //表格数据数组, 表格名, 表格属性, 属性名, 表格对象, 表格长度, 行数据, 行HTML代码
    var tempType, tempSet, tempArr, tempI;
    var formName;
    //处理form名为一个jQuery选择器
    if (form){
        formName = "#" + form + " ";
    }else{
        formName = "";
    }
    try{
        for (var key in data){
            if (typeof(data[key]) == "object" && key != "head"){
                //把数据填充到表格
                padBackTable(data[key], key);
            }else{
                tempType = $(formName + "#" + key).attr("type");        //回填的表单项类型
                if (!tempType){
                    //使用ID获取不到时使用NAME属性
                    tempSet = $(formName + "[name='" + key + "']");
                    tempType = tempSet.attr("type");
                }else{
                    //可使用ID获取
                    tempSet = $(formName + "#" + key);
                }
                if (tempType){
                    switch (tempType) {
                        case "text":
                        case "password":
                        case "hidden":
                        case "textarea":
                            tempSet.attr("value", data[key]);     //直接赋值
                            break;
                        case "radio":
                            tempSet.each(function(){
                                if ($.trim($(this).attr("value")) == $.trim(data[key])){
                                    $(this).attr("checked", "checked");
                                }
                            });
                            break;
                        case "checkbox":
                            tempSet.each(function(){
                                tempArr = data[key];//.split(ResCutArr);         //分割结果集中的数组元素
                                //使用循环判断，避免一个元素为另一个元素的子集的情况
                                for(tempI=0;tempI<tempArr.length;tempI++){
                                    if (tempArr[tempI] == $.trim($(this).attr("value"))){
                                        break;
                                    }
                                }
                                if (tempI != tempArr.length){
                                    $(this).attr("checked", "checked");
                                }
                            });
                            break;
                        default:
                            if (tempType.indexOf("select") != -1){
                                //对单项select赋值
                                tempSet.val(data[key]);
                            }
                            break;
                    }
                }else{
                    //非表单元素  使用ID
                    tempSet = $(formName + "#" + key);
                    if (tempSet){
                        tempSet.html(data[key]);
                    }
                }
            }
        }
        return true;
    }catch(e){
        debugAlert("function : padBackData()\nname : " + e.name + "\nmessage : " + e.message);
        return false;
    }
}

/**
     * 把一个json数据填充到表格中<br />表格为table标签，并且第一个tr标签的内容是th标签（表头）<br />
     * th标签中包含data-key属性，该属性中的值为json中的key，如果没有该属性或data中没有该值，该列不会填充数值
     * @param tableData 要填充的数据，必须是一个数组，数组中的元素为json
     * @param tableId 表格的id
     */
function padBackTable(tableData, tableId){
    var tableObj, tableLength, rowCode, keyList;
    try{
        tableObj = $("#" + tableId);
        if (tableObj.attr("id")){
            tableLength = 0;
            keyList = new Array();
            tableObj.find("tr:eq(0)").find("th").each(function(i){
                tableLength++;
                keyList[i] = $(this).attr("data-key");
                if (!keyList[i]){
                    keyList[i] = "";
                }
            });
            debugAlert("表格 " + tableData.tableId + "\n列长度：" + tableLength + "\ndata-key : " + keyList);
            tableObj.find("tr:gt(0)").remove();
            tableObj.attr("primary",tableData.primary);
            for(var index in tableData){
                rowCode = "<tr index='" + index + "'>";
                var rowData = tableData[index];
                for(var k=0;k<keyList.length;k++){
                    if (keyList[k]){
                        rowCode = rowCode + "<td>" + rowData[keyList[k]] + "</td>";
                    }else{
                        rowCode = rowCode + "<td>&nbsp;</td>";
                    }
                }
                rowCode = rowCode + "</tr>";
                tableObj.append(rowCode);
            }
            tableObj.find("tr:eq(0)").find("td").each(function(i){
                if ($(this).css("display") == "none"){
                    _hideCol(tableObj, i);
                }
            });
        }else{
            debugAlert("表格不存在！");
        }
    }catch(e){
        debugAlert("function : padBackTable()\nname : " + e.name + "\nmessage : " + e.message);
    }
}

/**
 * 针对ajax操作时的data参数<br />
 * 获取一个参数的值
 */
String.prototype.getParam = function(key){
    return dataToMap(this)[key];
};
/**
 * 针对ajax操作时的data参数<br />
 * 删除一个参数<br />
 * 函数会返回一个新的字符串，需要对原字符串重新赋值
 */
String.prototype.removeParam = function(key){
    var map = dataToMap(this);
    map[key] = null;
    return structData(map);
};

/**
 * 针对ajax操作时的data参数<br />
 * 增加一个参数，如果该参数已经存在则替换<br />
 * 函数会返回一个新的字符串，需要对原字符串重新赋值
 */
String.prototype.putParam = function(key, value){
    var map = dataToMap(this);
    map[key] = value;
    return structData(map);
};

/**
 * 把jquery serialize()转的表单数据转为map
 * @param data 表单数据
 */
function dataToMap(data){
    var arr = data.split("&");
    var map = new Object();
    var kv;
    for(var i in arr){
        kv = arr[i].split("=");
        if (kv.length == 2){
            if (map[kv[0]]){
                if (typeof(map[kv[0]]) == "string"){
                    var vr = new Array();
                    vr[0] = map[kv[0]];
                    vr[1] = kv[1];
                    map[kv[0]] = vr;
                }else{
                    map[kv[0]][map[kv[0]].length] = kv[1];
                }
            }else{
                map[kv[0]] = kv[1];
            }
        }
    }
    return map;
}

/**
 * 把map组装成表单数据包
 */
function structData(data){
    if (!data){
        return "";
    }
    if (typeof(data) != "object"){
        return data;
    }
    var str = "";
    for(var i in data){
        if (!data[i]){
            continue;
        }
        if (str) {
            str = str + "&";
        }
        if (typeof(data[i]) == "string"){
            str = str + i + "=" + data[i];
        }else{
            for(var j in data[i]){
                str = str + i + "=" + data[i][j] + "&";
            }
        }
    }
    return str;
}